Preview what would happen without executing mutating operations.

## sentry api --dry-run

Shows the fully resolved request without sending it:
- Method, full URL (with resolved base + query params)
- Headers and body
- Supports --json for machine-readable output
- Short alias: -n

## sentry project create --dry-run

Validates inputs and shows what would be created:
- Organization (resolved from args/config/DSN)
- Team (auto-selected/created as normal)
- Name, slug, platform
- Does NOT call createProject or fetch DSN
- Still validates platform and resolves org/team

Also adds output: "json" to the api command for --json/--fields
support (previously had no structured output mode).

Fixes #349

- Prevent team auto-creation side effect in dry-run mode by passing
  autoCreateSlug: undefined when --dry-run is set (BugBot HIGH)
- Use getDefaultSdkConfig().baseUrl in resolveRequestUrl to match
  rawApiRequest URL normalization, preventing double-slash URLs
  when SENTRY_URL has trailing slash (BugBot MEDIUM)

Continuation lines of JSON.stringify output are now indented to
align with the first line after the 'Body:     ' label prefix.

Also uses getDefaultSdkConfig().baseUrl (with trailing-slash
normalization) instead of raw getApiBaseUrl() in resolveRequestUrl
to match the URL rawApiRequest would actually use.

When an org has no teams, normal mode auto-creates a team. Dry-run
now reflects this by returning { slug, source: 'auto-created' }
without calling the createTeam API.

Previously dry-run passed autoCreateSlug: undefined which caused a
ContextError. Now passes dryRun: true to resolveOrCreateTeam which
skips the mutation while preserving the preview.

Mirror rawApiRequest behavior: when body is an object and no
Content-Type header was explicitly provided, auto-add
Content-Type: application/json in buildDryRunRequest.

Biome's auto-fix placed the type and function between import
statements. Move them after all imports to maintain standard
module structure.

…uest

Both code paths now return { data } through the standard output system:
- Dry-run: returns { data: { method, url, headers, body } } preview
- Normal: returns { data: response.body } after side-effect writes
  (verbose/include headers, error exit code)

Key changes:
- output: 'json' → { json: true } (JSON-only config, no human formatter)
- Make OutputConfig.human optional — when absent, renderCommandOutput
  always serializes as JSON regardless of --json flag
- Remove buildDryRunRequest — inline request preview construction using
  resolveRequestUrl + new resolveEffectiveHeaders helper
- Remove handleResponse — its behaviors are inlined in func:
  verbose/include headers as pre-return side effects, silent mode
  returns void, error uses process.exitCode (not process.exit) so
  the output wrapper can render before the process exits
- Remove DryRunRequest type, writeJson import

Tests: replace handleResponse tests (8) and buildDryRunRequest tests
(4+5 property) with resolveEffectiveHeaders tests (6+4 property).
288 tests pass across 3 files.

Stricli overwrites process.exitCode after the command returns,
so process.exitCode = 1 was silently reset to 0. For error
responses, write JSON directly then process.exit(1). Success
responses still use return-based { data } through the output
system.

…ttern

Both dry-run and normal response paths now return { data } through the
output system. No more imperative writeJson/writeResponseBody calls.

Changes:
- Add OutputError class (extends CliError) for commands that produce
  valid output but should exit non-zero. The buildCommand wrapper
  catches it, renders data through the output system, then calls
  process.exit(). This replaces the muddled exitCode field on
  CommandOutput<T>.
- Add formatApiResponse human formatter — preserves raw strings (plain
  text, HTML error pages) without JSON quoting, JSON-formats objects.
  Does NOT add trailing newline (renderCommandOutput appends it).
- Api command uses output: { json: true, human: formatApiResponse }
  instead of flag-only output: "json". Error responses throw
  OutputError(response.body) instead of returning { exitCode: 1 }.
- Remove writeResponseBody function and writeJson import from api.ts.
- Separate stdout/stderr in test context to prevent Stricli error
  messages from polluting JSON output assertions.

Replace imperative writeVerboseRequest, writeVerboseResponse, and
writeResponseHeaders functions with return-based output:

- Default: return raw response.body
- --include: return { status, headers, body } envelope
- --verbose: return { request, status, headers, body } full envelope

The human formatter (formatApiResponse) handles all three shapes:
- Raw body → formatBody (JSON-format objects, passthrough strings)
- --include envelope → HTTP status + headers + body
- --verbose envelope → '> ' request block + '< ' response block + body

JSON mode gets the same structured data — --include/--verbose now
produce structured JSON output instead of mixed text.

Also: --silent + error uses OutputError(null) instead of bare
process.exit(1), keeping the framework in control of exit codes.

Delete dead functions: writeResponseHeaders, writeVerboseRequest,
writeVerboseResponse.

--include wraps the body in { status, headers, body } which breaks
--fields filtering (users would need --fields body.name instead of
--fields name). Remove it entirely.

--verbose request/response metadata is diagnostic info that belongs
on stderr, not in the return data. Move to logger.debug() calls via
consola — the framework already sets log level to debug when
--verbose is passed, so the log lines appear automatically.

The api command now always returns raw response.body. No envelopes,
no shape changes per flags. --fields works directly on API response
fields.

Deleted: ApiResponseEnvelope type, isEnvelope() guard, formatBody()
(renamed back to formatApiResponse), envelope rendering logic,
headersToObject helper, --include flag + -i alias.

…utput bug

- Delete E2E tests for removed --include/-i flag
- Fix --verbose E2E test: check stderr (logger.debug) not stdout
- Fix renderCommandOutput null data bug: skip rendering when
  OutputError.data is null/undefined instead of writing spurious \n
- Update api docs: replace --include example with --verbose section
- Regenerate SKILL.md to remove stale --include references

Consola's BasicReporter (used when stderr is piped, e.g. in CI or
Bun.spawn) routes debug and info messages to stdout instead of stderr.
This contaminated command output when --verbose was used in non-TTY
contexts.

Fix: set stdout: process.stderr in createConsola() so ALL diagnostic
log output goes to stderr regardless of reporter or TTY mode.

- Guard verbose logging with !flags.silent to prevent leak when
  --verbose and --silent are combined (BugBot finding)
- Extract logRequest() and logResponse() helpers to reduce func
  cognitive complexity from 17 to within limit